home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / compiler / ast.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2009-11-11  |  69KB  |  1,846 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''Python abstract syntax node definitions
  5.  
  6. This file is automatically generated by Tools/compiler/astgen.py
  7. '''
  8. from compiler.consts import CO_VARARGS, CO_VARKEYWORDS
  9.  
  10. def flatten(seq):
  11.     l = []
  12.     for elt in seq:
  13.         t = type(elt)
  14.         if t is tuple or t is list:
  15.             for elt2 in flatten(elt):
  16.                 l.append(elt2)
  17.             
  18.         l.append(elt)
  19.     
  20.     return l
  21.  
  22.  
  23. def flatten_nodes(seq):
  24.     return _[1]
  25.  
  26. nodes = { }
  27.  
  28. class Node:
  29.     '''Abstract base class for ast nodes.'''
  30.     
  31.     def getChildren(self):
  32.         pass
  33.  
  34.     
  35.     def __iter__(self):
  36.         for n in self.getChildren():
  37.             yield n
  38.         
  39.  
  40.     
  41.     def asList(self):
  42.         return self.getChildren()
  43.  
  44.     
  45.     def getChildNodes(self):
  46.         pass
  47.  
  48.  
  49.  
  50. class EmptyNode(Node):
  51.     pass
  52.  
  53.  
  54. class Expression(Node):
  55.     nodes['expression'] = 'Expression'
  56.     
  57.     def __init__(self, node):
  58.         self.node = node
  59.  
  60.     
  61.     def getChildren(self):
  62.         return (self.node,)
  63.  
  64.     
  65.     def getChildNodes(self):
  66.         return (self.node,)
  67.  
  68.     
  69.     def __repr__(self):
  70.         return 'Expression(%s)' % repr(self.node)
  71.  
  72.  
  73.  
  74. class Add(Node):
  75.     
  76.     def __init__(self, .1, lineno = None):
  77.         (left, right) = .1
  78.         self.left = left
  79.         self.right = right
  80.         self.lineno = lineno
  81.  
  82.     
  83.     def getChildren(self):
  84.         return (self.left, self.right)
  85.  
  86.     
  87.     def getChildNodes(self):
  88.         return (self.left, self.right)
  89.  
  90.     
  91.     def __repr__(self):
  92.         return 'Add((%s, %s))' % (repr(self.left), repr(self.right))
  93.  
  94.  
  95.  
  96. class And(Node):
  97.     
  98.     def __init__(self, nodes, lineno = None):
  99.         self.nodes = nodes
  100.         self.lineno = lineno
  101.  
  102.     
  103.     def getChildren(self):
  104.         return tuple(flatten(self.nodes))
  105.  
  106.     
  107.     def getChildNodes(self):
  108.         nodelist = []
  109.         nodelist.extend(flatten_nodes(self.nodes))
  110.         return tuple(nodelist)
  111.  
  112.     
  113.     def __repr__(self):
  114.         return 'And(%s)' % (repr(self.nodes),)
  115.  
  116.  
  117.  
  118. class AssAttr(Node):
  119.     
  120.     def __init__(self, expr, attrname, flags, lineno = None):
  121.         self.expr = expr
  122.         self.attrname = attrname
  123.         self.flags = flags
  124.         self.lineno = lineno
  125.  
  126.     
  127.     def getChildren(self):
  128.         return (self.expr, self.attrname, self.flags)
  129.  
  130.     
  131.     def getChildNodes(self):
  132.         return (self.expr,)
  133.  
  134.     
  135.     def __repr__(self):
  136.         return 'AssAttr(%s, %s, %s)' % (repr(self.expr), repr(self.attrname), repr(self.flags))
  137.  
  138.  
  139.  
  140. class AssList(Node):
  141.     
  142.     def __init__(self, nodes, lineno = None):
  143.         self.nodes = nodes
  144.         self.lineno = lineno
  145.  
  146.     
  147.     def getChildren(self):
  148.         return tuple(flatten(self.nodes))
  149.  
  150.     
  151.     def getChildNodes(self):
  152.         nodelist = []
  153.         nodelist.extend(flatten_nodes(self.nodes))
  154.         return tuple(nodelist)
  155.  
  156.     
  157.     def __repr__(self):
  158.         return 'AssList(%s)' % (repr(self.nodes),)
  159.  
  160.  
  161.  
  162. class AssName(Node):
  163.     
  164.     def __init__(self, name, flags, lineno = None):
  165.         self.name = name
  166.         self.flags = flags
  167.         self.lineno = lineno
  168.  
  169.     
  170.     def getChildren(self):
  171.         return (self.name, self.flags)
  172.  
  173.     
  174.     def getChildNodes(self):
  175.         return ()
  176.  
  177.     
  178.     def __repr__(self):
  179.         return 'AssName(%s, %s)' % (repr(self.name), repr(self.flags))
  180.  
  181.  
  182.  
  183. class AssTuple(Node):
  184.     
  185.     def __init__(self, nodes, lineno = None):
  186.         self.nodes = nodes
  187.         self.lineno = lineno
  188.  
  189.     
  190.     def getChildren(self):
  191.         return tuple(flatten(self.nodes))
  192.  
  193.     
  194.     def getChildNodes(self):
  195.         nodelist = []
  196.         nodelist.extend(flatten_nodes(self.nodes))
  197.         return tuple(nodelist)
  198.  
  199.     
  200.     def __repr__(self):
  201.         return 'AssTuple(%s)' % (repr(self.nodes),)
  202.  
  203.  
  204.  
  205. class Assert(Node):
  206.     
  207.     def __init__(self, test, fail, lineno = None):
  208.         self.test = test
  209.         self.fail = fail
  210.         self.lineno = lineno
  211.  
  212.     
  213.     def getChildren(self):
  214.         children = []
  215.         children.append(self.test)
  216.         children.append(self.fail)
  217.         return tuple(children)
  218.  
  219.     
  220.     def getChildNodes(self):
  221.         nodelist = []
  222.         nodelist.append(self.test)
  223.         if self.fail is not None:
  224.             nodelist.append(self.fail)
  225.         
  226.         return tuple(nodelist)
  227.  
  228.     
  229.     def __repr__(self):
  230.         return 'Assert(%s, %s)' % (repr(self.test), repr(self.fail))
  231.  
  232.  
  233.  
  234. class Assign(Node):
  235.     
  236.     def __init__(self, nodes, expr, lineno = None):
  237.         self.nodes = nodes
  238.         self.expr = expr
  239.         self.lineno = lineno
  240.  
  241.     
  242.     def getChildren(self):
  243.         children = []
  244.         children.extend(flatten(self.nodes))
  245.         children.append(self.expr)
  246.         return tuple(children)
  247.  
  248.     
  249.     def getChildNodes(self):
  250.         nodelist = []
  251.         nodelist.extend(flatten_nodes(self.nodes))
  252.         nodelist.append(self.expr)
  253.         return tuple(nodelist)
  254.  
  255.     
  256.     def __repr__(self):
  257.         return 'Assign(%s, %s)' % (repr(self.nodes), repr(self.expr))
  258.  
  259.  
  260.  
  261. class AugAssign(Node):
  262.     
  263.     def __init__(self, node, op, expr, lineno = None):
  264.         self.node = node
  265.         self.op = op
  266.         self.expr = expr
  267.         self.lineno = lineno
  268.  
  269.     
  270.     def getChildren(self):
  271.         return (self.node, self.op, self.expr)
  272.  
  273.     
  274.     def getChildNodes(self):
  275.         return (self.node, self.expr)
  276.  
  277.     
  278.     def __repr__(self):
  279.         return 'AugAssign(%s, %s, %s)' % (repr(self.node), repr(self.op), repr(self.expr))
  280.  
  281.  
  282.  
  283. class Backquote(Node):
  284.     
  285.     def __init__(self, expr, lineno = None):
  286.         self.expr = expr
  287.         self.lineno = lineno
  288.  
  289.     
  290.     def getChildren(self):
  291.         return (self.expr,)
  292.  
  293.     
  294.     def getChildNodes(self):
  295.         return (self.expr,)
  296.  
  297.     
  298.     def __repr__(self):
  299.         return 'Backquote(%s)' % (repr(self.expr),)
  300.  
  301.  
  302.  
  303. class Bitand(Node):
  304.     
  305.     def __init__(self, nodes, lineno = None):
  306.         self.nodes = nodes
  307.         self.lineno = lineno
  308.  
  309.     
  310.     def getChildren(self):
  311.         return tuple(flatten(self.nodes))
  312.  
  313.     
  314.     def getChildNodes(self):
  315.         nodelist = []
  316.         nodelist.extend(flatten_nodes(self.nodes))
  317.         return tuple(nodelist)
  318.  
  319.     
  320.     def __repr__(self):
  321.         return 'Bitand(%s)' % (repr(self.nodes),)
  322.  
  323.  
  324.  
  325. class Bitor(Node):
  326.     
  327.     def __init__(self, nodes, lineno = None):
  328.         self.nodes = nodes
  329.         self.lineno = lineno
  330.  
  331.     
  332.     def getChildren(self):
  333.         return tuple(flatten(self.nodes))
  334.  
  335.     
  336.     def getChildNodes(self):
  337.         nodelist = []
  338.         nodelist.extend(flatten_nodes(self.nodes))
  339.         return tuple(nodelist)
  340.  
  341.     
  342.     def __repr__(self):
  343.         return 'Bitor(%s)' % (repr(self.nodes),)
  344.  
  345.  
  346.  
  347. class Bitxor(Node):
  348.     
  349.     def __init__(self, nodes, lineno = None):
  350.         self.nodes = nodes
  351.         self.lineno = lineno
  352.  
  353.     
  354.     def getChildren(self):
  355.         return tuple(flatten(self.nodes))
  356.  
  357.     
  358.     def getChildNodes(self):
  359.         nodelist = []
  360.         nodelist.extend(flatten_nodes(self.nodes))
  361.         return tuple(nodelist)
  362.  
  363.     
  364.     def __repr__(self):
  365.         return 'Bitxor(%s)' % (repr(self.nodes),)
  366.  
  367.  
  368.  
  369. class Break(Node):
  370.     
  371.     def __init__(self, lineno = None):
  372.         self.lineno = lineno
  373.  
  374.     
  375.     def getChildren(self):
  376.         return ()
  377.  
  378.     
  379.     def getChildNodes(self):
  380.         return ()
  381.  
  382.     
  383.     def __repr__(self):
  384.         return 'Break()'
  385.  
  386.  
  387.  
  388. class CallFunc(Node):
  389.     
  390.     def __init__(self, node, args, star_args = None, dstar_args = None, lineno = None):
  391.         self.node = node
  392.         self.args = args
  393.         self.star_args = star_args
  394.         self.dstar_args = dstar_args
  395.         self.lineno = lineno
  396.  
  397.     
  398.     def getChildren(self):
  399.         children = []
  400.         children.append(self.node)
  401.         children.extend(flatten(self.args))
  402.         children.append(self.star_args)
  403.         children.append(self.dstar_args)
  404.         return tuple(children)
  405.  
  406.     
  407.     def getChildNodes(self):
  408.         nodelist = []
  409.         nodelist.append(self.node)
  410.         nodelist.extend(flatten_nodes(self.args))
  411.         if self.star_args is not None:
  412.             nodelist.append(self.star_args)
  413.         
  414.         if self.dstar_args is not None:
  415.             nodelist.append(self.dstar_args)
  416.         
  417.         return tuple(nodelist)
  418.  
  419.     
  420.     def __repr__(self):
  421.         return 'CallFunc(%s, %s, %s, %s)' % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
  422.  
  423.  
  424.  
  425. class Class(Node):
  426.     
  427.     def __init__(self, name, bases, doc, code, decorators = None, lineno = None):
  428.         self.name = name
  429.         self.bases = bases
  430.         self.doc = doc
  431.         self.code = code
  432.         self.decorators = decorators
  433.         self.lineno = lineno
  434.  
  435.     
  436.     def getChildren(self):
  437.         children = []
  438.         children.append(self.name)
  439.         children.extend(flatten(self.bases))
  440.         children.append(self.doc)
  441.         children.append(self.code)
  442.         children.append(self.decorators)
  443.         return tuple(children)
  444.  
  445.     
  446.     def getChildNodes(self):
  447.         nodelist = []
  448.         nodelist.extend(flatten_nodes(self.bases))
  449.         nodelist.append(self.code)
  450.         if self.decorators is not None:
  451.             nodelist.append(self.decorators)
  452.         
  453.         return tuple(nodelist)
  454.  
  455.     
  456.     def __repr__(self):
  457.         return 'Class(%s, %s, %s, %s, %s)' % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code), repr(self.decorators))
  458.  
  459.  
  460.  
  461. class Compare(Node):
  462.     
  463.     def __init__(self, expr, ops, lineno = None):
  464.         self.expr = expr
  465.         self.ops = ops
  466.         self.lineno = lineno
  467.  
  468.     
  469.     def getChildren(self):
  470.         children = []
  471.         children.append(self.expr)
  472.         children.extend(flatten(self.ops))
  473.         return tuple(children)
  474.  
  475.     
  476.     def getChildNodes(self):
  477.         nodelist = []
  478.         nodelist.append(self.expr)
  479.         nodelist.extend(flatten_nodes(self.ops))
  480.         return tuple(nodelist)
  481.  
  482.     
  483.     def __repr__(self):
  484.         return 'Compare(%s, %s)' % (repr(self.expr), repr(self.ops))
  485.  
  486.  
  487.  
  488. class Const(Node):
  489.     
  490.     def __init__(self, value, lineno = None):
  491.         self.value = value
  492.         self.lineno = lineno
  493.  
  494.     
  495.     def getChildren(self):
  496.         return (self.value,)
  497.  
  498.     
  499.     def getChildNodes(self):
  500.         return ()
  501.  
  502.     
  503.     def __repr__(self):
  504.         return 'Const(%s)' % (repr(self.value),)
  505.  
  506.  
  507.  
  508. class Continue(Node):
  509.     
  510.     def __init__(self, lineno = None):
  511.         self.lineno = lineno
  512.  
  513.     
  514.     def getChildren(self):
  515.         return ()
  516.  
  517.     
  518.     def getChildNodes(self):
  519.         return ()
  520.  
  521.     
  522.     def __repr__(self):
  523.         return 'Continue()'
  524.  
  525.  
  526.  
  527. class Decorators(Node):
  528.     
  529.     def __init__(self, nodes, lineno = None):
  530.         self.nodes = nodes
  531.         self.lineno = lineno
  532.  
  533.     
  534.     def getChildren(self):
  535.         return tuple(flatten(self.nodes))
  536.  
  537.     
  538.     def getChildNodes(self):
  539.         nodelist = []
  540.         nodelist.extend(flatten_nodes(self.nodes))
  541.         return tuple(nodelist)
  542.  
  543.     
  544.     def __repr__(self):
  545.         return 'Decorators(%s)' % (repr(self.nodes),)
  546.  
  547.  
  548.  
  549. class Dict(Node):
  550.     
  551.     def __init__(self, items, lineno = None):
  552.         self.items = items
  553.         self.lineno = lineno
  554.  
  555.     
  556.     def getChildren(self):
  557.         return tuple(flatten(self.items))
  558.  
  559.     
  560.     def getChildNodes(self):
  561.         nodelist = []
  562.         nodelist.extend(flatten_nodes(self.items))
  563.         return tuple(nodelist)
  564.  
  565.     
  566.     def __repr__(self):
  567.         return 'Dict(%s)' % (repr(self.items),)
  568.  
  569.  
  570.  
  571. class Discard(Node):
  572.     
  573.     def __init__(self, expr, lineno = None):
  574.         self.expr = expr
  575.         self.lineno = lineno
  576.  
  577.     
  578.     def getChildren(self):
  579.         return (self.expr,)
  580.  
  581.     
  582.     def getChildNodes(self):
  583.         return (self.expr,)
  584.  
  585.     
  586.     def __repr__(self):
  587.         return 'Discard(%s)' % (repr(self.expr),)
  588.  
  589.  
  590.  
  591. class Div(Node):
  592.     
  593.     def __init__(self, .1, lineno = None):
  594.         (left, right) = .1
  595.         self.left = left
  596.         self.right = right
  597.         self.lineno = lineno
  598.  
  599.     
  600.     def getChildren(self):
  601.         return (self.left, self.right)
  602.  
  603.     
  604.     def getChildNodes(self):
  605.         return (self.left, self.right)
  606.  
  607.     
  608.     def __repr__(self):
  609.         return 'Div((%s, %s))' % (repr(self.left), repr(self.right))
  610.  
  611.  
  612.  
  613. class Ellipsis(Node):
  614.     
  615.     def __init__(self, lineno = None):
  616.         self.lineno = lineno
  617.  
  618.     
  619.     def getChildren(self):
  620.         return ()
  621.  
  622.     
  623.     def getChildNodes(self):
  624.         return ()
  625.  
  626.     
  627.     def __repr__(self):
  628.         return 'Ellipsis()'
  629.  
  630.  
  631.  
  632. class Exec(Node):
  633.     
  634.     def __init__(self, expr, locals, globals, lineno = None):
  635.         self.expr = expr
  636.         self.locals = locals
  637.         self.globals = globals
  638.         self.lineno = lineno
  639.  
  640.     
  641.     def getChildren(self):
  642.         children = []
  643.         children.append(self.expr)
  644.         children.append(self.locals)
  645.         children.append(self.globals)
  646.         return tuple(children)
  647.  
  648.     
  649.     def getChildNodes(self):
  650.         nodelist = []
  651.         nodelist.append(self.expr)
  652.         if self.locals is not None:
  653.             nodelist.append(self.locals)
  654.         
  655.         if self.globals is not None:
  656.             nodelist.append(self.globals)
  657.         
  658.         return tuple(nodelist)
  659.  
  660.     
  661.     def __repr__(self):
  662.         return 'Exec(%s, %s, %s)' % (repr(self.expr), repr(self.locals), repr(self.globals))
  663.  
  664.  
  665.  
  666. class FloorDiv(Node):
  667.     
  668.     def __init__(self, .1, lineno = None):
  669.         (left, right) = .1
  670.         self.left = left
  671.         self.right = right
  672.         self.lineno = lineno
  673.  
  674.     
  675.     def getChildren(self):
  676.         return (self.left, self.right)
  677.  
  678.     
  679.     def getChildNodes(self):
  680.         return (self.left, self.right)
  681.  
  682.     
  683.     def __repr__(self):
  684.         return 'FloorDiv((%s, %s))' % (repr(self.left), repr(self.right))
  685.  
  686.  
  687.  
  688. class For(Node):
  689.     
  690.     def __init__(self, assign, list, body, else_, lineno = None):
  691.         self.assign = assign
  692.         self.list = list
  693.         self.body = body
  694.         self.else_ = else_
  695.         self.lineno = lineno
  696.  
  697.     
  698.     def getChildren(self):
  699.         children = []
  700.         children.append(self.assign)
  701.         children.append(self.list)
  702.         children.append(self.body)
  703.         children.append(self.else_)
  704.         return tuple(children)
  705.  
  706.     
  707.     def getChildNodes(self):
  708.         nodelist = []
  709.         nodelist.append(self.assign)
  710.         nodelist.append(self.list)
  711.         nodelist.append(self.body)
  712.         if self.else_ is not None:
  713.             nodelist.append(self.else_)
  714.         
  715.         return tuple(nodelist)
  716.  
  717.     
  718.     def __repr__(self):
  719.         return 'For(%s, %s, %s, %s)' % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))
  720.  
  721.  
  722.  
  723. class From(Node):
  724.     
  725.     def __init__(self, modname, names, level, lineno = None):
  726.         self.modname = modname
  727.         self.names = names
  728.         self.level = level
  729.         self.lineno = lineno
  730.  
  731.     
  732.     def getChildren(self):
  733.         return (self.modname, self.names, self.level)
  734.  
  735.     
  736.     def getChildNodes(self):
  737.         return ()
  738.  
  739.     
  740.     def __repr__(self):
  741.         return 'From(%s, %s, %s)' % (repr(self.modname), repr(self.names), repr(self.level))
  742.  
  743.  
  744.  
  745. class Function(Node):
  746.     
  747.     def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno = None):
  748.         self.decorators = decorators
  749.         self.name = name
  750.         self.argnames = argnames
  751.         self.defaults = defaults
  752.         self.flags = flags
  753.         self.doc = doc
  754.         self.code = code
  755.         self.lineno = lineno
  756.         self.varargs = None
  757.         self.kwargs = None
  758.         if flags & CO_VARARGS:
  759.             self.varargs = 1
  760.         
  761.         if flags & CO_VARKEYWORDS:
  762.             self.kwargs = 1
  763.         
  764.  
  765.     
  766.     def getChildren(self):
  767.         children = []
  768.         children.append(self.decorators)
  769.         children.append(self.name)
  770.         children.append(self.argnames)
  771.         children.extend(flatten(self.defaults))
  772.         children.append(self.flags)
  773.         children.append(self.doc)
  774.         children.append(self.code)
  775.         return tuple(children)
  776.  
  777.     
  778.     def getChildNodes(self):
  779.         nodelist = []
  780.         if self.decorators is not None:
  781.             nodelist.append(self.decorators)
  782.         
  783.         nodelist.extend(flatten_nodes(self.defaults))
  784.         nodelist.append(self.code)
  785.         return tuple(nodelist)
  786.  
  787.     
  788.     def __repr__(self):
  789.         return 'Function(%s, %s, %s, %s, %s, %s, %s)' % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code))
  790.  
  791.  
  792.  
  793. class GenExpr(Node):
  794.     
  795.     def __init__(self, code, lineno = None):
  796.         self.code = code
  797.         self.lineno = lineno
  798.         self.argnames = [
  799.             '.0']
  800.         self.varargs = None
  801.         self.kwargs = None
  802.  
  803.     
  804.     def getChildren(self):
  805.         return (self.code,)
  806.  
  807.     
  808.     def getChildNodes(self):
  809.         return (self.code,)
  810.  
  811.     
  812.     def __repr__(self):
  813.         return 'GenExpr(%s)' % (repr(self.code),)
  814.  
  815.  
  816.  
  817. class GenExprFor(Node):
  818.     
  819.     def __init__(self, assign, iter, ifs, lineno = None):
  820.         self.assign = assign
  821.         self.iter = iter
  822.         self.ifs = ifs
  823.         self.lineno = lineno
  824.         self.is_outmost = False
  825.  
  826.     
  827.     def getChildren(self):
  828.         children = []
  829.         children.append(self.assign)
  830.         children.append(self.iter)
  831.         children.extend(flatten(self.ifs))
  832.         return tuple(children)
  833.  
  834.     
  835.     def getChildNodes(self):
  836.         nodelist = []
  837.         nodelist.append(self.assign)
  838.         nodelist.append(self.iter)
  839.         nodelist.extend(flatten_nodes(self.ifs))
  840.         return tuple(nodelist)
  841.  
  842.     
  843.     def __repr__(self):
  844.         return 'GenExprFor(%s, %s, %s)' % (repr(self.assign), repr(self.iter), repr(self.ifs))
  845.  
  846.  
  847.  
  848. class GenExprIf(Node):
  849.     
  850.     def __init__(self, test, lineno = None):
  851.         self.test = test
  852.         self.lineno = lineno
  853.  
  854.     
  855.     def getChildren(self):
  856.         return (self.test,)
  857.  
  858.     
  859.     def getChildNodes(self):
  860.         return (self.test,)
  861.  
  862.     
  863.     def __repr__(self):
  864.         return 'GenExprIf(%s)' % (repr(self.test),)
  865.  
  866.  
  867.  
  868. class GenExprInner(Node):
  869.     
  870.     def __init__(self, expr, quals, lineno = None):
  871.         self.expr = expr
  872.         self.quals = quals
  873.         self.lineno = lineno
  874.  
  875.     
  876.     def getChildren(self):
  877.         children = []
  878.         children.append(self.expr)
  879.         children.extend(flatten(self.quals))
  880.         return tuple(children)
  881.  
  882.     
  883.     def getChildNodes(self):
  884.         nodelist = []
  885.         nodelist.append(self.expr)
  886.         nodelist.extend(flatten_nodes(self.quals))
  887.         return tuple(nodelist)
  888.  
  889.     
  890.     def __repr__(self):
  891.         return 'GenExprInner(%s, %s)' % (repr(self.expr), repr(self.quals))
  892.  
  893.  
  894.  
  895. class Getattr(Node):
  896.     
  897.     def __init__(self, expr, attrname, lineno = None):
  898.         self.expr = expr
  899.         self.attrname = attrname
  900.         self.lineno = lineno
  901.  
  902.     
  903.     def getChildren(self):
  904.         return (self.expr, self.attrname)
  905.  
  906.     
  907.     def getChildNodes(self):
  908.         return (self.expr,)
  909.  
  910.     
  911.     def __repr__(self):
  912.         return 'Getattr(%s, %s)' % (repr(self.expr), repr(self.attrname))
  913.  
  914.  
  915.  
  916. class Global(Node):
  917.     
  918.     def __init__(self, names, lineno = None):
  919.         self.names = names
  920.         self.lineno = lineno
  921.  
  922.     
  923.     def getChildren(self):
  924.         return (self.names,)
  925.  
  926.     
  927.     def getChildNodes(self):
  928.         return ()
  929.  
  930.     
  931.     def __repr__(self):
  932.         return 'Global(%s)' % (repr(self.names),)
  933.  
  934.  
  935.  
  936. class If(Node):
  937.     
  938.     def __init__(self, tests, else_, lineno = None):
  939.         self.tests = tests
  940.         self.else_ = else_
  941.         self.lineno = lineno
  942.  
  943.     
  944.     def getChildren(self):
  945.         children = []
  946.         children.extend(flatten(self.tests))
  947.         children.append(self.else_)
  948.         return tuple(children)
  949.  
  950.     
  951.     def getChildNodes(self):
  952.         nodelist = []
  953.         nodelist.extend(flatten_nodes(self.tests))
  954.         if self.else_ is not None:
  955.             nodelist.append(self.else_)
  956.         
  957.         return tuple(nodelist)
  958.  
  959.     
  960.     def __repr__(self):
  961.         return 'If(%s, %s)' % (repr(self.tests), repr(self.else_))
  962.  
  963.  
  964.  
  965. class IfExp(Node):
  966.     
  967.     def __init__(self, test, then, else_, lineno = None):
  968.         self.test = test
  969.         self.then = then
  970.         self.else_ = else_
  971.         self.lineno = lineno
  972.  
  973.     
  974.     def getChildren(self):
  975.         return (self.test, self.then, self.else_)
  976.  
  977.     
  978.     def getChildNodes(self):
  979.         return (self.test, self.then, self.else_)
  980.  
  981.     
  982.     def __repr__(self):
  983.         return 'IfExp(%s, %s, %s)' % (repr(self.test), repr(self.then), repr(self.else_))
  984.  
  985.  
  986.  
  987. class Import(Node):
  988.     
  989.     def __init__(self, names, lineno = None):
  990.         self.names = names
  991.         self.lineno = lineno
  992.  
  993.     
  994.     def getChildren(self):
  995.         return (self.names,)
  996.  
  997.     
  998.     def getChildNodes(self):
  999.         return ()
  1000.  
  1001.     
  1002.     def __repr__(self):
  1003.         return 'Import(%s)' % (repr(self.names),)
  1004.  
  1005.  
  1006.  
  1007. class Invert(Node):
  1008.     
  1009.     def __init__(self, expr, lineno = None):
  1010.         self.expr = expr
  1011.         self.lineno = lineno
  1012.  
  1013.     
  1014.     def getChildren(self):
  1015.         return (self.expr,)
  1016.  
  1017.     
  1018.     def getChildNodes(self):
  1019.         return (self.expr,)
  1020.  
  1021.     
  1022.     def __repr__(self):
  1023.         return 'Invert(%s)' % (repr(self.expr),)
  1024.  
  1025.  
  1026.  
  1027. class Keyword(Node):
  1028.     
  1029.     def __init__(self, name, expr, lineno = None):
  1030.         self.name = name
  1031.         self.expr = expr
  1032.         self.lineno = lineno
  1033.  
  1034.     
  1035.     def getChildren(self):
  1036.         return (self.name, self.expr)
  1037.  
  1038.     
  1039.     def getChildNodes(self):
  1040.         return (self.expr,)
  1041.  
  1042.     
  1043.     def __repr__(self):
  1044.         return 'Keyword(%s, %s)' % (repr(self.name), repr(self.expr))
  1045.  
  1046.  
  1047.  
  1048. class Lambda(Node):
  1049.     
  1050.     def __init__(self, argnames, defaults, flags, code, lineno = None):
  1051.         self.argnames = argnames
  1052.         self.defaults = defaults
  1053.         self.flags = flags
  1054.         self.code = code
  1055.         self.lineno = lineno
  1056.         self.varargs = None
  1057.         self.kwargs = None
  1058.         if flags & CO_VARARGS:
  1059.             self.varargs = 1
  1060.         
  1061.         if flags & CO_VARKEYWORDS:
  1062.             self.kwargs = 1
  1063.         
  1064.  
  1065.     
  1066.     def getChildren(self):
  1067.         children = []
  1068.         children.append(self.argnames)
  1069.         children.extend(flatten(self.defaults))
  1070.         children.append(self.flags)
  1071.         children.append(self.code)
  1072.         return tuple(children)
  1073.  
  1074.     
  1075.     def getChildNodes(self):
  1076.         nodelist = []
  1077.         nodelist.extend(flatten_nodes(self.defaults))
  1078.         nodelist.append(self.code)
  1079.         return tuple(nodelist)
  1080.  
  1081.     
  1082.     def __repr__(self):
  1083.         return 'Lambda(%s, %s, %s, %s)' % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
  1084.  
  1085.  
  1086.  
  1087. class LeftShift(Node):
  1088.     
  1089.     def __init__(self, .1, lineno = None):
  1090.         (left, right) = .1
  1091.         self.left = left
  1092.         self.right = right
  1093.         self.lineno = lineno
  1094.  
  1095.     
  1096.     def getChildren(self):
  1097.         return (self.left, self.right)
  1098.  
  1099.     
  1100.     def getChildNodes(self):
  1101.         return (self.left, self.right)
  1102.  
  1103.     
  1104.     def __repr__(self):
  1105.         return 'LeftShift((%s, %s))' % (repr(self.left), repr(self.right))
  1106.  
  1107.  
  1108.  
  1109. class List(Node):
  1110.     
  1111.     def __init__(self, nodes, lineno = None):
  1112.         self.nodes = nodes
  1113.         self.lineno = lineno
  1114.  
  1115.     
  1116.     def getChildren(self):
  1117.         return tuple(flatten(self.nodes))
  1118.  
  1119.     
  1120.     def getChildNodes(self):
  1121.         nodelist = []
  1122.         nodelist.extend(flatten_nodes(self.nodes))
  1123.         return tuple(nodelist)
  1124.  
  1125.     
  1126.     def __repr__(self):
  1127.         return 'List(%s)' % (repr(self.nodes),)
  1128.  
  1129.  
  1130.  
  1131. class ListComp(Node):
  1132.     
  1133.     def __init__(self, expr, quals, lineno = None):
  1134.         self.expr = expr
  1135.         self.quals = quals
  1136.         self.lineno = lineno
  1137.  
  1138.     
  1139.     def getChildren(self):
  1140.         children = []
  1141.         children.append(self.expr)
  1142.         children.extend(flatten(self.quals))
  1143.         return tuple(children)
  1144.  
  1145.     
  1146.     def getChildNodes(self):
  1147.         nodelist = []
  1148.         nodelist.append(self.expr)
  1149.         nodelist.extend(flatten_nodes(self.quals))
  1150.         return tuple(nodelist)
  1151.  
  1152.     
  1153.     def __repr__(self):
  1154.         return 'ListComp(%s, %s)' % (repr(self.expr), repr(self.quals))
  1155.  
  1156.  
  1157.  
  1158. class ListCompFor(Node):
  1159.     
  1160.     def __init__(self, assign, list, ifs, lineno = None):
  1161.         self.assign = assign
  1162.         self.list = list
  1163.         self.ifs = ifs
  1164.         self.lineno = lineno
  1165.  
  1166.     
  1167.     def getChildren(self):
  1168.         children = []
  1169.         children.append(self.assign)
  1170.         children.append(self.list)
  1171.         children.extend(flatten(self.ifs))
  1172.         return tuple(children)
  1173.  
  1174.     
  1175.     def getChildNodes(self):
  1176.         nodelist = []
  1177.         nodelist.append(self.assign)
  1178.         nodelist.append(self.list)
  1179.         nodelist.extend(flatten_nodes(self.ifs))
  1180.         return tuple(nodelist)
  1181.  
  1182.     
  1183.     def __repr__(self):
  1184.         return 'ListCompFor(%s, %s, %s)' % (repr(self.assign), repr(self.list), repr(self.ifs))
  1185.  
  1186.  
  1187.  
  1188. class ListCompIf(Node):
  1189.     
  1190.     def __init__(self, test, lineno = None):
  1191.         self.test = test
  1192.         self.lineno = lineno
  1193.  
  1194.     
  1195.     def getChildren(self):
  1196.         return (self.test,)
  1197.  
  1198.     
  1199.     def getChildNodes(self):
  1200.         return (self.test,)
  1201.  
  1202.     
  1203.     def __repr__(self):
  1204.         return 'ListCompIf(%s)' % (repr(self.test),)
  1205.  
  1206.  
  1207.  
  1208. class Mod(Node):
  1209.     
  1210.     def __init__(self, .1, lineno = None):
  1211.         (left, right) = .1
  1212.         self.left = left
  1213.         self.right = right
  1214.         self.lineno = lineno
  1215.  
  1216.     
  1217.     def getChildren(self):
  1218.         return (self.left, self.right)
  1219.  
  1220.     
  1221.     def getChildNodes(self):
  1222.         return (self.left, self.right)
  1223.  
  1224.     
  1225.     def __repr__(self):
  1226.         return 'Mod((%s, %s))' % (repr(self.left), repr(self.right))
  1227.  
  1228.  
  1229.  
  1230. class Module(Node):
  1231.     
  1232.     def __init__(self, doc, node, lineno = None):
  1233.         self.doc = doc
  1234.         self.node = node
  1235.         self.lineno = lineno
  1236.  
  1237.     
  1238.     def getChildren(self):
  1239.         return (self.doc, self.node)
  1240.  
  1241.     
  1242.     def getChildNodes(self):
  1243.         return (self.node,)
  1244.  
  1245.     
  1246.     def __repr__(self):
  1247.         return 'Module(%s, %s)' % (repr(self.doc), repr(self.node))
  1248.  
  1249.  
  1250.  
  1251. class Mul(Node):
  1252.     
  1253.     def __init__(self, .1, lineno = None):
  1254.         (left, right) = .1
  1255.         self.left = left
  1256.         self.right = right
  1257.         self.lineno = lineno
  1258.  
  1259.     
  1260.     def getChildren(self):
  1261.         return (self.left, self.right)
  1262.  
  1263.     
  1264.     def getChildNodes(self):
  1265.         return (self.left, self.right)
  1266.  
  1267.     
  1268.     def __repr__(self):
  1269.         return 'Mul((%s, %s))' % (repr(self.left), repr(self.right))
  1270.  
  1271.  
  1272.  
  1273. class Name(Node):
  1274.     
  1275.     def __init__(self, name, lineno = None):
  1276.         self.name = name
  1277.         self.lineno = lineno
  1278.  
  1279.     
  1280.     def getChildren(self):
  1281.         return (self.name,)
  1282.  
  1283.     
  1284.     def getChildNodes(self):
  1285.         return ()
  1286.  
  1287.     
  1288.     def __repr__(self):
  1289.         return 'Name(%s)' % (repr(self.name),)
  1290.  
  1291.  
  1292.  
  1293. class Not(Node):
  1294.     
  1295.     def __init__(self, expr, lineno = None):
  1296.         self.expr = expr
  1297.         self.lineno = lineno
  1298.  
  1299.     
  1300.     def getChildren(self):
  1301.         return (self.expr,)
  1302.  
  1303.     
  1304.     def getChildNodes(self):
  1305.         return (self.expr,)
  1306.  
  1307.     
  1308.     def __repr__(self):
  1309.         return 'Not(%s)' % (repr(self.expr),)
  1310.  
  1311.  
  1312.  
  1313. class Or(Node):
  1314.     
  1315.     def __init__(self, nodes, lineno = None):
  1316.         self.nodes = nodes
  1317.         self.lineno = lineno
  1318.  
  1319.     
  1320.     def getChildren(self):
  1321.         return tuple(flatten(self.nodes))
  1322.  
  1323.     
  1324.     def getChildNodes(self):
  1325.         nodelist = []
  1326.         nodelist.extend(flatten_nodes(self.nodes))
  1327.         return tuple(nodelist)
  1328.  
  1329.     
  1330.     def __repr__(self):
  1331.         return 'Or(%s)' % (repr(self.nodes),)
  1332.  
  1333.  
  1334.  
  1335. class Pass(Node):
  1336.     
  1337.     def __init__(self, lineno = None):
  1338.         self.lineno = lineno
  1339.  
  1340.     
  1341.     def getChildren(self):
  1342.         return ()
  1343.  
  1344.     
  1345.     def getChildNodes(self):
  1346.         return ()
  1347.  
  1348.     
  1349.     def __repr__(self):
  1350.         return 'Pass()'
  1351.  
  1352.  
  1353.  
  1354. class Power(Node):
  1355.     
  1356.     def __init__(self, .1, lineno = None):
  1357.         (left, right) = .1
  1358.         self.left = left
  1359.         self.right = right
  1360.         self.lineno = lineno
  1361.  
  1362.     
  1363.     def getChildren(self):
  1364.         return (self.left, self.right)
  1365.  
  1366.     
  1367.     def getChildNodes(self):
  1368.         return (self.left, self.right)
  1369.  
  1370.     
  1371.     def __repr__(self):
  1372.         return 'Power((%s, %s))' % (repr(self.left), repr(self.right))
  1373.  
  1374.  
  1375.  
  1376. class Print(Node):
  1377.     
  1378.     def __init__(self, nodes, dest, lineno = None):
  1379.         self.nodes = nodes
  1380.         self.dest = dest
  1381.         self.lineno = lineno
  1382.  
  1383.     
  1384.     def getChildren(self):
  1385.         children = []
  1386.         children.extend(flatten(self.nodes))
  1387.         children.append(self.dest)
  1388.         return tuple(children)
  1389.  
  1390.     
  1391.     def getChildNodes(self):
  1392.         nodelist = []
  1393.         nodelist.extend(flatten_nodes(self.nodes))
  1394.         if self.dest is not None:
  1395.             nodelist.append(self.dest)
  1396.         
  1397.         return tuple(nodelist)
  1398.  
  1399.     
  1400.     def __repr__(self):
  1401.         return 'Print(%s, %s)' % (repr(self.nodes), repr(self.dest))
  1402.  
  1403.  
  1404.  
  1405. class Printnl(Node):
  1406.     
  1407.     def __init__(self, nodes, dest, lineno = None):
  1408.         self.nodes = nodes
  1409.         self.dest = dest
  1410.         self.lineno = lineno
  1411.  
  1412.     
  1413.     def getChildren(self):
  1414.         children = []
  1415.         children.extend(flatten(self.nodes))
  1416.         children.append(self.dest)
  1417.         return tuple(children)
  1418.  
  1419.     
  1420.     def getChildNodes(self):
  1421.         nodelist = []
  1422.         nodelist.extend(flatten_nodes(self.nodes))
  1423.         if self.dest is not None:
  1424.             nodelist.append(self.dest)
  1425.         
  1426.         return tuple(nodelist)
  1427.  
  1428.     
  1429.     def __repr__(self):
  1430.         return 'Printnl(%s, %s)' % (repr(self.nodes), repr(self.dest))
  1431.  
  1432.  
  1433.  
  1434. class Raise(Node):
  1435.     
  1436.     def __init__(self, expr1, expr2, expr3, lineno = None):
  1437.         self.expr1 = expr1
  1438.         self.expr2 = expr2
  1439.         self.expr3 = expr3
  1440.         self.lineno = lineno
  1441.  
  1442.     
  1443.     def getChildren(self):
  1444.         children = []
  1445.         children.append(self.expr1)
  1446.         children.append(self.expr2)
  1447.         children.append(self.expr3)
  1448.         return tuple(children)
  1449.  
  1450.     
  1451.     def getChildNodes(self):
  1452.         nodelist = []
  1453.         if self.expr1 is not None:
  1454.             nodelist.append(self.expr1)
  1455.         
  1456.         if self.expr2 is not None:
  1457.             nodelist.append(self.expr2)
  1458.         
  1459.         if self.expr3 is not None:
  1460.             nodelist.append(self.expr3)
  1461.         
  1462.         return tuple(nodelist)
  1463.  
  1464.     
  1465.     def __repr__(self):
  1466.         return 'Raise(%s, %s, %s)' % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
  1467.  
  1468.  
  1469.  
  1470. class Return(Node):
  1471.     
  1472.     def __init__(self, value, lineno = None):
  1473.         self.value = value
  1474.         self.lineno = lineno
  1475.  
  1476.     
  1477.     def getChildren(self):
  1478.         return (self.value,)
  1479.  
  1480.     
  1481.     def getChildNodes(self):
  1482.         return (self.value,)
  1483.  
  1484.     
  1485.     def __repr__(self):
  1486.         return 'Return(%s)' % (repr(self.value),)
  1487.  
  1488.  
  1489.  
  1490. class RightShift(Node):
  1491.     
  1492.     def __init__(self, .1, lineno = None):
  1493.         (left, right) = .1
  1494.         self.left = left
  1495.         self.right = right
  1496.         self.lineno = lineno
  1497.  
  1498.     
  1499.     def getChildren(self):
  1500.         return (self.left, self.right)
  1501.  
  1502.     
  1503.     def getChildNodes(self):
  1504.         return (self.left, self.right)
  1505.  
  1506.     
  1507.     def __repr__(self):
  1508.         return 'RightShift((%s, %s))' % (repr(self.left), repr(self.right))
  1509.  
  1510.  
  1511.  
  1512. class Slice(Node):
  1513.     
  1514.     def __init__(self, expr, flags, lower, upper, lineno = None):
  1515.         self.expr = expr
  1516.         self.flags = flags
  1517.         self.lower = lower
  1518.         self.upper = upper
  1519.         self.lineno = lineno
  1520.  
  1521.     
  1522.     def getChildren(self):
  1523.         children = []
  1524.         children.append(self.expr)
  1525.         children.append(self.flags)
  1526.         children.append(self.lower)
  1527.         children.append(self.upper)
  1528.         return tuple(children)
  1529.  
  1530.     
  1531.     def getChildNodes(self):
  1532.         nodelist = []
  1533.         nodelist.append(self.expr)
  1534.         if self.lower is not None:
  1535.             nodelist.append(self.lower)
  1536.         
  1537.         if self.upper is not None:
  1538.             nodelist.append(self.upper)
  1539.         
  1540.         return tuple(nodelist)
  1541.  
  1542.     
  1543.     def __repr__(self):
  1544.         return 'Slice(%s, %s, %s, %s)' % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
  1545.  
  1546.  
  1547.  
  1548. class Sliceobj(Node):
  1549.     
  1550.     def __init__(self, nodes, lineno = None):
  1551.         self.nodes = nodes
  1552.         self.lineno = lineno
  1553.  
  1554.     
  1555.     def getChildren(self):
  1556.         return tuple(flatten(self.nodes))
  1557.  
  1558.     
  1559.     def getChildNodes(self):
  1560.         nodelist = []
  1561.         nodelist.extend(flatten_nodes(self.nodes))
  1562.         return tuple(nodelist)
  1563.  
  1564.     
  1565.     def __repr__(self):
  1566.         return 'Sliceobj(%s)' % (repr(self.nodes),)
  1567.  
  1568.  
  1569.  
  1570. class Stmt(Node):
  1571.     
  1572.     def __init__(self, nodes, lineno = None):
  1573.         self.nodes = nodes
  1574.         self.lineno = lineno
  1575.  
  1576.     
  1577.     def getChildren(self):
  1578.         return tuple(flatten(self.nodes))
  1579.  
  1580.     
  1581.     def getChildNodes(self):
  1582.         nodelist = []
  1583.         nodelist.extend(flatten_nodes(self.nodes))
  1584.         return tuple(nodelist)
  1585.  
  1586.     
  1587.     def __repr__(self):
  1588.         return 'Stmt(%s)' % (repr(self.nodes),)
  1589.  
  1590.  
  1591.  
  1592. class Sub(Node):
  1593.     
  1594.     def __init__(self, .1, lineno = None):
  1595.         (left, right) = .1
  1596.         self.left = left
  1597.         self.right = right
  1598.         self.lineno = lineno
  1599.  
  1600.     
  1601.     def getChildren(self):
  1602.         return (self.left, self.right)
  1603.  
  1604.     
  1605.     def getChildNodes(self):
  1606.         return (self.left, self.right)
  1607.  
  1608.     
  1609.     def __repr__(self):
  1610.         return 'Sub((%s, %s))' % (repr(self.left), repr(self.right))
  1611.  
  1612.  
  1613.  
  1614. class Subscript(Node):
  1615.     
  1616.     def __init__(self, expr, flags, subs, lineno = None):
  1617.         self.expr = expr
  1618.         self.flags = flags
  1619.         self.subs = subs
  1620.         self.lineno = lineno
  1621.  
  1622.     
  1623.     def getChildren(self):
  1624.         children = []
  1625.         children.append(self.expr)
  1626.         children.append(self.flags)
  1627.         children.extend(flatten(self.subs))
  1628.         return tuple(children)
  1629.  
  1630.     
  1631.     def getChildNodes(self):
  1632.         nodelist = []
  1633.         nodelist.append(self.expr)
  1634.         nodelist.extend(flatten_nodes(self.subs))
  1635.         return tuple(nodelist)
  1636.  
  1637.     
  1638.     def __repr__(self):
  1639.         return 'Subscript(%s, %s, %s)' % (repr(self.expr), repr(self.flags), repr(self.subs))
  1640.  
  1641.  
  1642.  
  1643. class TryExcept(Node):
  1644.     
  1645.     def __init__(self, body, handlers, else_, lineno = None):
  1646.         self.body = body
  1647.         self.handlers = handlers
  1648.         self.else_ = else_
  1649.         self.lineno = lineno
  1650.  
  1651.     
  1652.     def getChildren(self):
  1653.         children = []
  1654.         children.append(self.body)
  1655.         children.extend(flatten(self.handlers))
  1656.         children.append(self.else_)
  1657.         return tuple(children)
  1658.  
  1659.     
  1660.     def getChildNodes(self):
  1661.         nodelist = []
  1662.         nodelist.append(self.body)
  1663.         nodelist.extend(flatten_nodes(self.handlers))
  1664.         if self.else_ is not None:
  1665.             nodelist.append(self.else_)
  1666.         
  1667.         return tuple(nodelist)
  1668.  
  1669.     
  1670.     def __repr__(self):
  1671.         return 'TryExcept(%s, %s, %s)' % (repr(self.body), repr(self.handlers), repr(self.else_))
  1672.  
  1673.  
  1674.  
  1675. class TryFinally(Node):
  1676.     
  1677.     def __init__(self, body, final, lineno = None):
  1678.         self.body = body
  1679.         self.final = final
  1680.         self.lineno = lineno
  1681.  
  1682.     
  1683.     def getChildren(self):
  1684.         return (self.body, self.final)
  1685.  
  1686.     
  1687.     def getChildNodes(self):
  1688.         return (self.body, self.final)
  1689.  
  1690.     
  1691.     def __repr__(self):
  1692.         return 'TryFinally(%s, %s)' % (repr(self.body), repr(self.final))
  1693.  
  1694.  
  1695.  
  1696. class Tuple(Node):
  1697.     
  1698.     def __init__(self, nodes, lineno = None):
  1699.         self.nodes = nodes
  1700.         self.lineno = lineno
  1701.  
  1702.     
  1703.     def getChildren(self):
  1704.         return tuple(flatten(self.nodes))
  1705.  
  1706.     
  1707.     def getChildNodes(self):
  1708.         nodelist = []
  1709.         nodelist.extend(flatten_nodes(self.nodes))
  1710.         return tuple(nodelist)
  1711.  
  1712.     
  1713.     def __repr__(self):
  1714.         return 'Tuple(%s)' % (repr(self.nodes),)
  1715.  
  1716.  
  1717.  
  1718. class UnaryAdd(Node):
  1719.     
  1720.     def __init__(self, expr, lineno = None):
  1721.         self.expr = expr
  1722.         self.lineno = lineno
  1723.  
  1724.     
  1725.     def getChildren(self):
  1726.         return (self.expr,)
  1727.  
  1728.     
  1729.     def getChildNodes(self):
  1730.         return (self.expr,)
  1731.  
  1732.     
  1733.     def __repr__(self):
  1734.         return 'UnaryAdd(%s)' % (repr(self.expr),)
  1735.  
  1736.  
  1737.  
  1738. class UnarySub(Node):
  1739.     
  1740.     def __init__(self, expr, lineno = None):
  1741.         self.expr = expr
  1742.         self.lineno = lineno
  1743.  
  1744.     
  1745.     def getChildren(self):
  1746.         return (self.expr,)
  1747.  
  1748.     
  1749.     def getChildNodes(self):
  1750.         return (self.expr,)
  1751.  
  1752.     
  1753.     def __repr__(self):
  1754.         return 'UnarySub(%s)' % (repr(self.expr),)
  1755.  
  1756.  
  1757.  
  1758. class While(Node):
  1759.     
  1760.     def __init__(self, test, body, else_, lineno = None):
  1761.         self.test = test
  1762.         self.body = body
  1763.         self.else_ = else_
  1764.         self.lineno = lineno
  1765.  
  1766.     
  1767.     def getChildren(self):
  1768.         children = []
  1769.         children.append(self.test)
  1770.         children.append(self.body)
  1771.         children.append(self.else_)
  1772.         return tuple(children)
  1773.  
  1774.     
  1775.     def getChildNodes(self):
  1776.         nodelist = []
  1777.         nodelist.append(self.test)
  1778.         nodelist.append(self.body)
  1779.         if self.else_ is not None:
  1780.             nodelist.append(self.else_)
  1781.         
  1782.         return tuple(nodelist)
  1783.  
  1784.     
  1785.     def __repr__(self):
  1786.         return 'While(%s, %s, %s)' % (repr(self.test), repr(self.body), repr(self.else_))
  1787.  
  1788.  
  1789.  
  1790. class With(Node):
  1791.     
  1792.     def __init__(self, expr, vars, body, lineno = None):
  1793.         self.expr = expr
  1794.         self.vars = vars
  1795.         self.body = body
  1796.         self.lineno = lineno
  1797.  
  1798.     
  1799.     def getChildren(self):
  1800.         children = []
  1801.         children.append(self.expr)
  1802.         children.append(self.vars)
  1803.         children.append(self.body)
  1804.         return tuple(children)
  1805.  
  1806.     
  1807.     def getChildNodes(self):
  1808.         nodelist = []
  1809.         nodelist.append(self.expr)
  1810.         if self.vars is not None:
  1811.             nodelist.append(self.vars)
  1812.         
  1813.         nodelist.append(self.body)
  1814.         return tuple(nodelist)
  1815.  
  1816.     
  1817.     def __repr__(self):
  1818.         return 'With(%s, %s, %s)' % (repr(self.expr), repr(self.vars), repr(self.body))
  1819.  
  1820.  
  1821.  
  1822. class Yield(Node):
  1823.     
  1824.     def __init__(self, value, lineno = None):
  1825.         self.value = value
  1826.         self.lineno = lineno
  1827.  
  1828.     
  1829.     def getChildren(self):
  1830.         return (self.value,)
  1831.  
  1832.     
  1833.     def getChildNodes(self):
  1834.         return (self.value,)
  1835.  
  1836.     
  1837.     def __repr__(self):
  1838.         return 'Yield(%s)' % (repr(self.value),)
  1839.  
  1840.  
  1841. for name, obj in globals().items():
  1842.     if isinstance(obj, type) and issubclass(obj, Node):
  1843.         nodes[name.lower()] = obj
  1844.         continue
  1845.  
  1846.